Klien HTTP Python Terbongkar: Membedah Requests, httpx, dan urllib3

Dalam dunia pengembangan perangkat lunak modern, komunikasi adalah kunci. Aplikasi jarang berfungsi secara terisolasi; mereka berkomunikasi dengan basis data, layanan pihak ketiga, dan mikrosevice lainnya, terutama melalui API melalui Hypertext Transfer Protocol (HTTP). Bagi pengembang Python, membuat permintaan HTTP ini adalah tugas mendasar, dan pustaka yang Anda pilih untuk pekerjaan ini dapat secara signifikan memengaruhi produktivitas, kinerja aplikasi, dan keterpeliharaan kode Anda.

Ekosistem Python menawarkan banyak pilihan alat untuk tujuan ini, tetapi tiga nama secara konsisten menonjol: urllib3, fondasi yang kuat; Requests, standar yang sangat digemari; dan httpx, pesaing modern yang mampu asinkron. Memilih di antara mereka bukan tentang menemukan pustaka "terbaik" tunggal, melainkan memahami kekuatan unik mereka dan memilih alat yang tepat untuk kebutuhan spesifik Anda. Panduan ini akan memberikan perbandingan profesional yang mendalam untuk membantu Anda membuat keputusan yang tepat.

Memahami Dasar: Apa Itu Klien HTTP?

Pada intinya, klien HTTP adalah bagian dari perangkat lunak yang dirancang untuk mengirim permintaan HTTP ke server dan memproses respons HTTP yang diterimanya. Definisi sederhana ini menyembunyikan banyak kompleksitas. Pustaka klien HTTP yang tangguh menangani banyak detail tingkat rendah, termasuk:

• Mengelola soket dan koneksi jaringan.
• Memformat permintaan HTTP dengan benar beserta header, body, dan metode (GET, POST, PUT, dll.).
• Menangani pengalihan dan batas waktu.
• Mengelola cookie dan sesi untuk komunikasi stateful.
• Menangani berbagai pengodean konten (seperti JSON atau data formulir).
• Menangani SSL/TLS untuk koneksi HTTPS yang aman.
• Menggunakan kembali koneksi untuk kinerja yang lebih baik (pooling koneksi).

Meskipun pustaka standar Python menyertakan modul seperti urllib.request, modul tersebut sering dianggap terlalu tingkat rendah dan merepotkan untuk penggunaan sehari-hari. Hal ini telah mengarah pada pengembangan pustaka pihak ketiga yang lebih kuat, ramah pengguna, yang mengabstraksi kompleksitas ini, memungkinkan pengembang untuk fokus pada logika aplikasi mereka.

Juara Klasik: urllib3

Sebelum kita membahas pustaka tingkat tinggi lainnya, penting untuk memahami urllib3. Ini adalah salah satu paket yang paling banyak diunduh di PyPI, bukan karena sebagian besar pengembang menggunakannya secara langsung, tetapi karena ini adalah mesin yang kuat dan handal yang menggerakkan banyak pustaka tingkat tinggi lainnya, terutama Requests.

Apa itu urllib3?

urllib3 adalah klien HTTP yang kuat dan berfokus pada keandalan untuk Python. Fokus utamanya adalah menyediakan fondasi yang andal dan efisien untuk komunikasi HTTP. Ini tidak dirancang dengan penekanan pada keanggunan API seperti Requests, melainkan pada kebenaran, kinerja, dan kontrol yang terperinci.

Fitur Utama dan Keunggulan

• Pooling Koneksi: Ini bisa dibilang fitur paling krusialnya. urllib3 mengelola kumpulan koneksi. Ketika Anda membuat permintaan ke host yang pernah Anda hubungi sebelumnya, ia menggunakan kembali koneksi yang ada daripada membuat yang baru. Ini secara drastis mengurangi latensi permintaan berturut-turut, karena overhead jabat tangan TCP dan TLS dihindari.
• Keamanan Thread: Sebuah instance PoolManager tunggal dapat dibagikan di beberapa thread, menjadikannya pilihan yang kuat untuk aplikasi multi-thread.
• Penanganan Kesalahan dan Percobaan Ulang yang Kuat: Ini menyediakan mekanisme canggih untuk mencoba ulang permintaan yang gagal, lengkap dengan strategi backoff yang dapat dikonfigurasi, yang sangat penting untuk membangun aplikasi tangguh yang berkomunikasi dengan layanan yang berpotensi tidak stabil.
• Kontrol Granular: Ini mengekspos banyak opsi konfigurasi, memungkinkan pengembang untuk menyempurnakan batas waktu, verifikasi TLS, pengaturan proxy, dan banyak lagi.
• Unggah Berkas: Ia memiliki dukungan yang sangat baik untuk pengodean data formulir multipart, sehingga mudah untuk mengunggah berkas secara efisien.

Contoh Kode: Membuat Permintaan GET

Menggunakan urllib3 lebih bertele-tele daripada rekan-rekannya yang tingkat tinggi, tetapi tetap mudah. Anda biasanya berinteraksi dengan instance PoolManager.

            
import urllib3
import json

# Disarankan untuk membuat satu instance PoolManager dan menggunakannya kembali
http = urllib3.PoolManager()

# Definisikan URL target
url = "https://api.github.com/users/python"

# Buat permintaan
# Catatan: Metode permintaan dilewatkan sebagai string ('GET')
# Objek respons adalah instance HTTPResponse
response = http.request("GET", url, headers={"User-Agent": "My-Urllib3-App/1.0"})

# Periksa status respons
if response.status == 200:
    # Data dikembalikan sebagai objek byte dan perlu didekode
    data_bytes = response.data
    data_str = data_bytes.decode("utf-8")
    
    # Parse JSON secara manual
    user_data = json.loads(data_str)
    
    print(f"User Name: {user_data['name']}")
    print(f"Public Repos: {user_data['public_repos']}")
else:
    print(f"Error: Received status code {response.status}")

# Koneksi secara otomatis dilepaskan kembali ke pool

            

              
                Copy
              
            
          

Kapan Menggunakan urllib3

• Ketika Anda sedang membangun pustaka atau kerangka kerja yang perlu membuat permintaan HTTP dan Anda ingin mengelola dependensi dengan cermat.
• Ketika Anda membutuhkan kinerja dan kontrol tertinggi atas manajemen koneksi dan logika percobaan ulang.
• Dalam sistem lama atau lingkungan terbatas di mana Anda perlu bergantung pada pustaka yang sering disertakan (vendored) dalam paket-paket utama lainnya.

Putusan tentang urllib3

Kelebihan: Sangat berkinerja tinggi, aman untuk thread, tangguh, dan menawarkan kontrol mendalam atas siklus hidup permintaan.
Kekurangan: API-nya bertele-tele dan kurang intuitif. Membutuhkan pekerjaan manual untuk tugas-tugas umum seperti dekode JSON dan pengodean parameter permintaan.

Pilihan Masyarakat: requests - "HTTP untuk Manusia"

Selama lebih dari satu dekade, requests telah menjadi standar de-facto untuk membuat permintaan HTTP di Python. Slogan terkenalnya, "HTTP for Humans," dengan sempurna merangkum filosofi desainnya. Ia menyediakan API yang indah, sederhana, dan elegan yang menyembunyikan kompleksitas yang mendasarinya yang dikelola oleh urllib3.

Apa itu requests?

requests adalah pustaka HTTP tingkat tinggi yang berfokus pada pengalaman pengembang dan kemudahan penggunaan. Ia membungkus kekuatan urllib3 dalam antarmuka yang intuitif, membuat tugas-tugas umum sangat sederhana sambil tetap menyediakan akses ke fitur-fitur canggih saat dibutuhkan.

Fitur Utama dan Keunggulan

• API Sederhana, Elegan: API-nya menyenangkan untuk dikerjakan. Membuat permintaan GET adalah satu baris kode yang mudah dibaca.
• Objek Sesi: Objek sesi adalah fitur dasar. Mereka mempertahankan parameter di seluruh permintaan, mengelola cookie secara otomatis, dan yang terpenting, menggunakan pooling koneksi urllib3 di balik layar. Menggunakan Session adalah cara yang direkomendasikan untuk mencapai kinerja tinggi dengan requests.
• Dekode JSON Bawaan: Berinteraksi dengan API JSON sangat mudah. Objek respons memiliki metode .json() yang secara otomatis mendekode badan respons dan mengembalikan kamus atau daftar Python.
• Dekompresi Konten Otomatis: Ia secara transparan menangani data respons terkompresi (gzip, deflate), jadi Anda tidak perlu memikirkannya.
• Penanganan Data Kompleks yang Anggun: Mengirim data formulir atau payload JSON semudah meneruskan kamus ke parameter data atau json.
• Domain dan URL Internasional: Dukungan luar biasa, siap pakai untuk web global.

Contoh Kode: Membuat Permintaan GET dan Menangani JSON

Bandingkan kesederhanaan contoh ini dengan versi urllib3. Perhatikan tidak adanya dekode manual atau parsing JSON.

            
import requests

# Pendekatan yang direkomendasikan untuk beberapa permintaan ke host yang sama
with requests.Session() as session:
    session.headers.update({"User-Agent": "My-Requests-App/1.0"})

    url = "https://api.github.com/users/python"

    try:
        # Membuat permintaan adalah satu panggilan fungsi
        response = session.get(url)
        
        # Mengeluarkan pengecualian untuk kode status buruk (4xx atau 5xx)
        response.raise_for_status()
        
        # Metode .json() menangani dekode dan parsing
        user_data = response.json()
        
        print(f"User Name: {user_data['name']}")
        print(f"Public Repos: {user_data['public_repos']}")

    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")


            

              
                Copy
              
            
          

Kapan Menggunakan requests

• Untuk sebagian besar tugas HTTP sinkron dalam aplikasi, skrip, dan proyek ilmu data.
• Saat berinteraksi dengan REST API.
• Untuk pembuatan prototipe cepat dan membangun alat internal.
• Ketika tujuan utama Anda adalah keterbacaan kode dan kecepatan pengembangan untuk I/O jaringan sinkron.

Batasan untuk Dipertimbangkan

Batasan terbesar requests di era modern adalah API-nya murni sinkron. Ia memblokir hingga respons diterima. Ini membuatnya tidak cocok untuk aplikasi konkurensi tinggi yang dibangun di atas kerangka kerja asinkron seperti asyncio, FastAPI, atau Starlette. Meskipun Anda dapat menggunakannya dalam thread pool, pendekatan ini kurang efisien daripada I/O asinkron native untuk menangani ribuan koneksi simultan.

Putusan tentang requests

Kelebihan: Sangat mudah digunakan, sangat mudah dibaca, set fitur yang kaya, komunitas besar, dan dokumentasi yang sangat baik.
Kekurangan: Hanya sinkron. Ini adalah kelemahan signifikan untuk aplikasi modern, berkinerja tinggi, dan terikat I/O.

Pesaing Modern: httpx - Penerus yang Siap Asinkron

httpx adalah klien HTTP modern, berfitur lengkap yang muncul untuk mengatasi batasan requests, terutama kurangnya dukungan asinkron. Ini dirancang untuk menjadi klien generasi berikutnya, merangkul fitur Python modern dan protokol web sambil menawarkan API yang akrab bagi mereka yang berasal dari requests.

Apa itu httpx?

httpx adalah klien HTTP serbaguna untuk Python yang menyediakan API sinkron dan asinkron. Fitur utamanya adalah dukungan kelas satu untuk sintaks async/await. Selanjutnya, ia membawa dukungan untuk protokol web modern seperti HTTP/2 dan HTTP/3, yang dapat menawarkan peningkatan kinerja yang signifikan.

Fitur Utama dan Keunggulan

• Dukungan Sinkron dan Asinkron: Ini adalah fitur penentuannya. Anda dapat menggunakan pustaka yang sama dan API yang sangat mirip untuk skrip sinkron tradisional dan aplikasi asinkron berkinerja tinggi. Unifikasi ini menyederhanakan manajemen dependensi dan mengurangi kurva pembelajaran.
• Dukungan HTTP/2 dan HTTP/3: Berbeda dengan requests, httpx dapat berkomunikasi dengan HTTP/2. Protokol ini memungkinkan multiplexing—mengirim beberapa permintaan dan respons melalui satu koneksi secara bersamaan—yang dapat secara dramatis mempercepat komunikasi dengan server modern yang mendukungnya.
• API yang Kompatibel dengan requests: API ini sengaja dirancang untuk menjadi pengganti langsung untuk requests dalam banyak kasus. Fungsi seperti httpx.get() dan objek seperti httpx.Client() (setara dengan requests.Session()) akan terasa langsung akrab.
• API Transport yang Dapat Diperluas: Ia memiliki API transport yang bersih dan terdefinisi dengan baik, yang membuatnya lebih mudah untuk menulis adapter kustom untuk hal-hal seperti mocking, caching, atau protokol jaringan kustom.

Contoh Kode: Sinkron, Asinkron, dan Klien

Pertama, contoh sinkron. Perhatikan bagaimana itu hampir identik dengan kode requests.

            
# Kode httpx sinkron
import httpx

url = "https://api.github.com/users/python-httpx"

with httpx.Client(headers={"User-Agent": "My-HTTPX-App/1.0"}) as client:
    try:
        response = client.get(url)
        response.raise_for_status()
        user_data = response.json()
        
        print(f"(Sync) User Name: {user_data['name']}")
        print(f"(Sync) Public Repos: {user_data['public_repos']}")

    except httpx.RequestError as e:
        print(f"An error occurred: {e}")

            

              
                Copy
              
            
          

Sekarang, versi asinkron. Strukturnya sama, tetapi memanfaatkan async/await untuk melakukan I/O non-pemblokiran.

            
# Kode httpx asinkron
import httpx
import asyncio

async def fetch_github_user():
    url = "https://api.github.com/users/python-httpx"
    
    # Gunakan AsyncClient untuk operasi asinkron
    async with httpx.AsyncClient(headers={"User-Agent": "My-HTTPX-App/1.0"}) as client:
        try:
            # Kata kunci 'await' menjeda eksekusi hingga panggilan jaringan selesai
            response = await client.get(url)
            response.raise_for_status()
            user_data = response.json()
            
            print(f"(Async) User Name: {user_data['name']}")
            print(f"(Async) Public Repos: {user_data['public_repos']}")

        except httpx.RequestError as e:
            print(f"An error occurred: {e}")

# Jalankan fungsi asinkron
asyncio.run(fetch_github_user())

            

              
                Copy
              
            
          

Kapan Menggunakan httpx

• Untuk setiap proyek baru yang dimulai hari ini. Sifat dual sinkron/asinkronnya menjadikannya pilihan yang paling serbaguna dan tahan masa depan. Bahkan jika Anda hanya memerlukan permintaan sinkron hari ini, menggunakan `httpx` berarti Anda siap untuk transisi yang mulus ke asinkron jika kebutuhan aplikasi Anda berkembang. Ini adalah pilihan yang jelas untuk setiap proyek yang melibatkan kerangka kerja web modern atau membutuhkan tingkat konkurensi yang tinggi.
• Saat membangun aplikasi dengan kerangka kerja asinkron seperti FastAPI, Starlette, Sanic, atau Django 3+.
• Ketika Anda perlu membuat sejumlah besar permintaan I/O-bound secara bersamaan (misalnya, memanggil ribuan API).
• Ketika Anda perlu berkomunikasi dengan server yang memanfaatkan HTTP/2 untuk kinerja.

Putusan tentang httpx

Kelebihan: Menawarkan API sinkron dan asinkron, mendukung HTTP/2, memiliki desain modern dan bersih, serta menyediakan API yang akrab bagi pengguna requests.
Kekurangan: Sebagai proyek yang lebih muda, ekosistem plugin pihak ketiganya tidak seluas requests, meskipun berkembang pesat.

Perbandingan Fitur: Sekilas

Ringkasan ini menyediakan referensi cepat untuk perbedaan utama antara ketiga pustaka tersebut.

Fitur: API Tingkat Tinggi, Ramah Pengguna

• urllib3: Tidak. Tingkat rendah dan bertele-tele.
• requests: Ya. Ini adalah kekuatan utamanya.
• httpx: Ya. Dirancang agar akrab bagi pengguna `requests`.

Fitur: API Sinkron

• urllib3: Ya.
• requests: Ya.
• httpx: Ya.

Fitur: API Asinkron (async/await)

• urllib3: Tidak.
• requests: Tidak.
• httpx: Ya. Ini adalah pembeda utamanya.

Fitur: Dukungan HTTP/2

• urllib3: Tidak.
• requests: Tidak.
• httpx: Ya.

Fitur: Pooling Koneksi

• urllib3: Ya. Fitur inti.
• requests: Ya (melalui `Session` objects).
• httpx: Ya (melalui `Client` dan `AsyncClient` objects).

Fitur: Dekode JSON Bawaan

• urllib3: Tidak. Membutuhkan dekode dan parsing manual.
• requests: Ya (melalui response.json()).
• httpx: Ya (melalui response.json()).

Pertimbangan Kinerja

Ketika membahas kinerja, konteks adalah segalanya. Untuk satu permintaan sederhana, perbedaan kinerja antara ketiga pustaka ini akan dapat diabaikan dan kemungkinan besar hilang dalam latensi jaringan.

Di mana perbedaan kinerja benar-benar muncul adalah dalam menangani konkurensi:

• `requests` dalam lingkungan multi-threaded: Ini adalah cara tradisional untuk mencapai konkurensi dengan `requests`. Ini berfungsi, tetapi thread memiliki overhead memori yang lebih tinggi dan dapat menderita biaya peralihan konteks, terutama saat jumlah tugas bersamaan bertambah hingga ratusan atau ribuan.
• `httpx` dengan `asyncio`: Untuk tugas yang terikat I/O seperti membuat panggilan API, `asyncio` jauh lebih efisien. Ia menggunakan satu thread dan event loop untuk mengelola ribuan koneksi bersamaan dengan overhead minimal. Jika aplikasi Anda perlu mengkueri ratusan microservice secara bersamaan, `httpx` akan secara masif mengungguli implementasi `requests` yang menggunakan thread.

Selain itu, dukungan `httpx` untuk HTTP/2 dapat memberikan peningkatan kinerja tambahan saat berkomunikasi dengan server yang juga mendukungnya, karena memungkinkan beberapa permintaan dikirim melalui koneksi TCP yang sama tanpa menunggu respons, mengurangi latensi.

Memilih Pustaka yang Tepat untuk Proyek Anda

Berdasarkan pembahasan mendalam ini, berikut adalah rekomendasi yang dapat ditindaklanjuti untuk para pengembang di seluruh dunia:

Gunakan `httpx` jika...

Anda memulai proyek Python baru pada tahun 2023 atau setelahnya. Sifat dual sinkron/asinkronnya menjadikannya pilihan yang paling serbaguna dan tahan masa depan. Bahkan jika Anda hanya memerlukan permintaan sinkron hari ini, menggunakan `httpx` berarti Anda siap untuk transisi yang mulus ke asinkron jika kebutuhan aplikasi Anda berkembang. Ini adalah pilihan yang jelas untuk setiap proyek yang melibatkan kerangka kerja web modern atau membutuhkan tingkat konkurensi yang tinggi.

Gunakan `requests` jika...

Anda sedang mengerjakan codebase lama yang sudah banyak menggunakan `requests`. Biaya migrasi mungkin tidak sepadan dengan manfaatnya jika aplikasi stabil dan tidak memiliki persyaratan konkurensi. Ini juga tetap menjadi pilihan yang sangat baik untuk skrip sederhana, sekali pakai di mana overhead pengaturan event loop asinkron tidak diperlukan dan keterbacaan adalah yang utama.

Gunakan `urllib3` jika...

Anda adalah penulis pustaka dan perlu membuat permintaan HTTP dengan dependensi minimal dan kontrol maksimal. Dengan bergantung pada `urllib3`, Anda menghindari memaksakan `requests` atau `httpx` pada pengguna Anda. Anda juga harus menggunakannya jika Anda memiliki persyaratan tingkat rendah yang sangat spesifik untuk manajemen koneksi atau TLS yang tidak diekspos oleh pustaka tingkat tinggi.

Kesimpulan

Lanskap klien HTTP Python menawarkan jalur evolusi yang jelas. `urllib3` menyediakan mesin yang kuat dan kokoh yang menopang ekosistem. `requests` dibangun di atas mesin tersebut untuk menciptakan API yang begitu intuitif dan digemari sehingga menjadi standar global, mendemokratisasi akses web bagi generasi programmer Python. Kini, `httpx` berdiri sebagai penerus modern, mempertahankan kegunaan brilian dari `requests` sambil mengintegrasikan fitur-fitur penting yang dibutuhkan untuk generasi perangkat lunak berikutnya: operasi asinkron dan protokol jaringan modern.

Bagi pengembang saat ini, pilihannya lebih jelas dari sebelumnya. Meskipun `requests` tetap menjadi alat yang dapat diandalkan untuk tugas-tugas sinkron, `httpx` adalah pilihan yang berwawasan ke depan untuk hampir semua pengembangan baru. Dengan memahami kekuatan masing-masing pustaka, Anda dapat dengan percaya diri memilih alat yang tepat untuk pekerjaan itu, memastikan aplikasi Anda tangguh, berkinerja tinggi, dan siap untuk masa depan.